package org.linearlist;

/**
 * @author: 默苍璃
 * @date: 2023-04-11 13:14
 * <p>
 * 串
 */
public class String {

    /**
     * 串中字符数组的初始长度
     */
    private int maxSize = 10;

    /**
     * 存储元素的数组对象
     */
    private char[] chars;

    /**
     * 保存串的当前长度
     */
    private int length;

    /**
     * 构造一个空串
     */
    public String() {
    }

    /**
     * 构造一个能保存n个字符的串
     *
     * @param n
     */
    public String(int n) {
        this.maxSize = n;
        this.chars = new char[n];
        this.length = 0;
    }


    /**
     * 复制串
     * 将串t复制给当前串
     *
     * @param t
     */
    public void copy(String t) {
        //若当前串无法容纳串t的内容，将扩充当前的容量
        if (this.maxSize < t.maxSize) {
            this.maxSize = t.maxSize;
            this.chars = new char[this.maxSize];
        }
        //初始化当前串的长度
        this.length = 0;
        for (int i = 0; i < t.getLength(); i++) {
            this.chars[i] = t.chars[i];
            this.length++;
        }
    }


    public boolean isEmpty() {
        return false;
    }   //判断当前串是否为空


    /**
     * 将当前串与串t进行比较
     * 若当前串等于串t，则返回值=0；若当前串>串t，则返回值1；若当前串<串t，则返回值-1
     *
     * @param t
     * @return
     */
    public int compare(String t) {
        int i = 0;
        while (this.chars[i] == t.chars[i] && i < this.length && i < t.getLength()) {
            i++;
        }
        if (i == this.length && i == t.length) {
            return 0;
        } else if (i == t.getLength() && i < this.length) {
            return 1;
        } else {
            return -1;
        }
    }


    public int getLength() {
        return 0;
    }               //求当前串的长度

    public boolean clear() {
        return false;
    }               //清空当前串


    /**
     * 串连接
     * 将指定串t连接到当前串中
     *
     * @param t
     */
    public void concat(String t) {
        //若当前串无法容纳串t的内容，则先扩充当前串的容量
        if (this.maxSize < this.length + t.getLength()) {

            //将当前串中的内容暂存到数组a中
            char[] a = new char[this.length];
            for (int i = 0; i < this.length; i++) {
                a[i] = this.chars[i];
            }

            //扩展当前串的容量
            this.maxSize = this.length + t.getLength();
            this.chars = new char[this.maxSize];

            //恢复当前串的原始状态
            for (int i = 0; i < a.length; i++) {
                this.chars[i] = a[i];
            }
        }
        //将串t的内容添加到当前串的尾部，实现连接操作
        for (int i = 0; i < t.getLength(); i++) {
            this.chars[this.length] = t.chars[i];
            this.length++;
        }
    }


    /**
     * 求子串
     * <p>
     * 从当前串中的第pos个字符开始连续提取len个字符而得到一个子串
     *
     * @param pos
     * @param len
     * @return
     */
    public String subString(int pos, int len) {
        //若提取的子串的起始位置与提取的子串的长度之和超过了当前串的长度，则操作非常并返回空串对象
        if (pos + len >= this.length) {
            return null;
        }
        //获取子串并返回
        String a = new String(len);
        for (int i = 0; i < len; i++) {
            a.chars[i] = this.chars[pos + i];
            a.length++;
        }
        return a;
    }

    public String subString(int pos) {
        return this;
    } //从当前串中的第pos个字符开始直到最后一个字符全部提取出来，得到一个子串


    /**
     * 串的模式匹配算法
     * 返回字符串t在当前串中首次出现的位置，若不存在t，返回-1
     *
     * @param t
     * @return
     */
    public int index(String t) {
        //若串t的长度大于当前串的长度，则直接返回-1，表示不存在
        if (this.length < t.getLength()) {
            return -1;
        }
        //设置标志变量a，其默认值表示不存在串t
        int a = -1;
        //从左往右查找串t
        for (int i = 0; i < this.length; i++) {
            int j = 0;
            while (j < t.getLength() && this.chars[i + j] == t.chars[j]) {
                if (this.chars[i + j] != t.chars[j]) {
                    break;
                }
                j++;
            }
            //如果找到了串t，则记录它在当前串中的起始位置
            if (j == t.getLength()) {
                a = i;
                break;
            }
        }
        return a;
    }


    public int lastIndex(String t) {
        return 0;
    }  //返回字符串t在当前串中最后一次出现的位置，若不存在t，返回-1

    public int replace(String t, String v) {
        return 0;
    }  //在当前串中用串v替换所有与串t相等的子串，并返回替换的次数

    public boolean insert(String t, int pos) {
        return false;
    } //将串t插入到当前串的第pos个位置上

    public boolean delete(int pos, int n) {
        return false;
    } //删除当前串从第pos个字符开始的连续len个字符

    public boolean remove(String t) {
        return false;
    }  //在当前串中删除所有与串t相等的子串，并返回删除的次数

    public void toUpperCase() {
    }             //将当前串的所有字母全部转换为大写字母

    public void toLowerCase() {
    }            //将当前串的所有字母全部转换为小写字母

}
